home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 010 / advent.arc / TURN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1984-05-18  |  15.2 KB  |  864 lines
  1.  
  2. /*    program TURN.C                        *\
  3. \*    WARNING: "advent.c" allocates GLOBAL storage space by    *\
  4. \*        including "advdef.h".                *\
  5. \*        All other modules use "advdec.h".        */
  6.  
  7.  
  8. #include    "stdio.h"    /* drv = 1.1st file 2.def 3.A    */
  9. #include    "advent.h"
  10. #include    "advdec.h"
  11.  
  12. extern    int    printf();
  13.  
  14.  
  15. /*
  16.     Routine to take 1 turn
  17. */
  18. turn()
  19. {
  20.     char    i;
  21.     /*
  22.         if closing, then he can't leave except via
  23.         the main office.
  24.     */
  25.     if (newloc < 9 && newloc != 0 && closing) {
  26.         rspeak(130);
  27.         newloc = loc;
  28.         if (!panic)
  29.             clock2 = 15;
  30.         panic = 1;
  31.     }
  32.     /*
  33.         see if a dwarf has seen him and has come
  34.         from where he wants to go.
  35.     */
  36.     if (newloc != loc && !forced(loc) && cond[loc]&NOPIRAT  ==  0)
  37.         for (i = 1; i< (DWARFMAX-1); ++i)
  38.             if (odloc[i] == newloc && dseen[i]) {
  39.                 newloc  =  loc;
  40.                 rspeak(2);
  41.                 break;
  42.             }
  43.  
  44.     dwarves();    /* & special dwarf(pirate who steals)    */
  45.  
  46.     /* added by BDS C conversion */
  47.     if (loc != newloc) {
  48.         ++turns;
  49.         loc = newloc;
  50. /*    causes occasional "move" with two describe & descitem    */
  51. /*    }    */            /* if (loc != newloc)    */
  52.  
  53.     /* check for death */
  54.     if (loc == 0) {
  55.         death();
  56.         return;
  57.     }
  58.  
  59.     /* check for forced move */
  60.     if (forced (loc)) {
  61.         describe();
  62.         domove();
  63.         return;
  64.     }
  65.  
  66.     /* check for wandering in dark */
  67.     if (wzdark && dark() && pct(35)) {
  68.         rspeak(23);
  69.         oldloc2 = loc;
  70.         death();
  71.         return;
  72.     }
  73.  
  74.     /* describe his situation */
  75.     describe();
  76.     if (!dark ()) {
  77.         ++visited[loc];
  78.         descitem();
  79.     }
  80. /*    causes occasional "move" with no describe & descitem    */
  81.     }                /* if (loc != newloc)    */
  82.  
  83.     if (closed) {
  84.         if (prop[OYSTER] < 0 && toting (OYSTER))
  85.             pspeak(OYSTER, 1);
  86.         for (i = 1; i <= MAXOBJ; ++i)
  87.             if (toting (i) && prop[i] < 0)
  88.                 prop[i] = -1-prop[i];
  89.     }
  90.  
  91.     wzdark = dark();
  92.     if (knfloc > 0 && knfloc != loc)
  93.         knfloc  =  0;
  94.  
  95.     if (stimer())    /* as the grains of sand slip by    */
  96.         return;
  97.  
  98.     while (!english())    /* retrieve player instructions    */
  99.         ;
  100.  
  101.     if (dbugflg)
  102.         printf("loc = %d, verb = %d, object = %d, \
  103.         motion = %d\n", loc, verb, object, motion);
  104.  
  105.     if (motion)        /* execute player instructions    */
  106.         domove();
  107.     else if (object)
  108.         doobj();
  109.     else
  110.         itverb();
  111. }
  112.  
  113. /*
  114.     Routine to describe current location
  115. */
  116. describe()
  117. {
  118.     if (toting(BEAR))
  119.         rspeak(141);
  120.     if (dark())
  121.         rspeak(16);
  122.     else if (visited[loc])
  123.         descsh(loc);
  124.     else
  125.         desclg(loc);
  126.     if (loc == 33 && pct(25) && !closing)
  127.         rspeak(8);
  128. }
  129.  
  130. /*
  131.     Routine to describe visible items
  132. */
  133. descitem()
  134. {
  135.     int    i, state;
  136.  
  137.     for (i = 1;i<MAXOBJ; ++i) {
  138.         if (at(i)) {
  139.             if (i == STEPS && toting(NUGGET))
  140.                 continue;
  141.             if (prop[i]<0) {
  142.                 if (closed)
  143.                     continue;
  144.                 else {
  145.                     prop[i] = 0;
  146.                     if (i == RUG || i == CHAIN)
  147.                         ++prop[i];
  148.                     --tally;
  149.                 }
  150.             }
  151.             if (i == STEPS && loc == fixed[STEPS])
  152.                 state = 1;
  153.             else
  154.                 state = prop[i];
  155.             pspeak(i, state);
  156.         }
  157.     }
  158.     if (tally == tally2 && tally != 0 && limit > 35)
  159.         limit = 35;
  160. }
  161.  
  162. /*
  163.     Routine to handle motion requests
  164. */
  165. domove()
  166. {
  167.     gettrav(loc);
  168.     switch(motion) {
  169.     case NULLX:
  170.         break;
  171.     case BACK:
  172.         goback();
  173.         break;
  174.     case LOOK:
  175.         if (detail++<3)
  176.             rspeak(15);
  177.         wzdark = 0;
  178.         visited[loc] = 0;
  179.         newloc = loc;
  180.         loc = 0;
  181.         break;
  182.     case CAVE:
  183.         if (loc<8)
  184.             rspeak(57);
  185.         else
  186.             rspeak(58);
  187.         break;
  188.     default:
  189.         oldloc2 = oldloc;
  190.         oldloc = loc;
  191.         dotrav();
  192.     }
  193. }
  194.  
  195. /*
  196.     Routine to handle request to return
  197.     from whence we came!
  198. */
  199. goback()
  200. {
  201.     int    kk, k2, want, temp;
  202.     struct trav strav[MAXTRAV];
  203.  
  204.     if (forced(oldloc))
  205.         want = oldloc2;
  206.     else
  207.         want = oldloc;
  208.     oldloc2 = oldloc;
  209.     oldloc = loc;
  210.     k2 = 0;
  211.     if (want == loc) {
  212.         rspeak(91);
  213.         return;
  214.     }
  215.     copytrv(travel, strav);
  216.     for (kk = 0; travel[kk].tdest != -1; ++kk) {
  217.         if (!travel[kk].tcond && travel[kk].tdest == want) {
  218.             motion = travel[kk].tverb;
  219.             dotrav();
  220.             return;
  221.         }
  222.         if (!travel[kk].tcond) {
  223.             k2 = kk;
  224.             temp = travel[kk].tdest;
  225.             gettrav(temp);
  226.             if (forced(temp) && travel[0].tdest == want)
  227.                 k2 = temp;
  228.             copytrv(strav, travel);
  229.         }
  230.     }
  231.     if (k2) {
  232.         motion = travel[k2].tverb;
  233.         dotrav();
  234.     }
  235.     else
  236.         rspeak(140);
  237. }
  238.  
  239. /*
  240.     Routine to copy a travel array
  241. */
  242. copytrv(trav1, trav2)
  243. struct trav *trav1, *trav2;
  244. {
  245.     int    i;
  246.  
  247.     for (i = 0; i<MAXTRAV; ++i) {
  248.         trav2 -> tdest = trav1 -> tdest;
  249.         trav2 -> tverb = trav1 -> tverb;
  250.         trav2 -> tcond = trav1 -> tcond;
  251.     }
  252. }
  253.  
  254. /*
  255.     Routine to figure out a new location
  256.     given current location and a motion.
  257. */
  258. dotrav()
  259. {
  260.     char    mvflag, hitflag, kk;
  261.     int    rdest, rverb, rcond, robject;
  262.     int    pctt;
  263.  
  264.     newloc = loc;
  265.     mvflag = hitflag = 0;
  266.     pctt = rand()%100;
  267.  
  268.     for (kk = 0; travel[kk].tdest>=0 && !mvflag; ++kk) {
  269.         rdest = travel[kk].tdest;
  270.         rverb = travel[kk].tverb;
  271.         rcond = travel[kk].tcond;
  272.         robject = rcond%100;
  273.  
  274.         if (dbugflg)
  275.             printf("rdest = %d, rverb = %d, rcond = %d, \
  276.             robject = %d in dotrav\n", rdest, rverb, \
  277.             rcond, robject);
  278.         if ((rverb != 1) && (rverb != motion) && !hitflag)
  279.             continue;
  280.         ++hitflag;
  281.         switch(rcond/100) {
  282.         case 0:
  283.             if ((rcond == 0) || (pctt < rcond))
  284.                 ++mvflag;
  285.             if (rcond && dbugflg)
  286.                 printf("%% move %d %d\n",
  287.                     pctt, mvflag);
  288.             break;
  289.         case 1:
  290.             if (robject == 0)
  291.                 ++mvflag;
  292.             else if (toting(robject))
  293.                 ++mvflag;
  294.             break;
  295.         case 2:
  296.             if (toting(robject) || at(robject))
  297.                 ++mvflag;
  298.             break;
  299.         case 3:
  300.         case 4:
  301.         case 5:
  302.         case 7:
  303.             if (prop[robject] != (rcond/100)-3)
  304.                 ++mvflag;
  305.             break;
  306.         default:
  307.             bug(37);
  308.         }
  309.     }
  310.     if (!mvflag)
  311.         badmove();
  312.     else if (rdest>500)
  313.         rspeak(rdest-500);
  314.     else if (rdest>300)
  315.         spcmove(rdest);
  316.     else {
  317.         newloc = rdest;
  318.         if (dbugflg)
  319.             printf("newloc in dotrav = %d\n", newloc);
  320.     }
  321. }
  322.  
  323. /*
  324.     The player tried a poor move option.
  325. */
  326. badmove()
  327. {
  328.     int    msg;
  329.  
  330.     msg = 12;
  331.     if (motion >= 43 && motion <=50) msg = 9;
  332.     if (motion == 29 || motion == 30) msg = 9;
  333.     if (motion == 7 || motion == 36 || motion == 37) msg = 10;
  334.     if (motion == 11 || motion == 19) msg = 11;
  335.     if (verb == FIND || verb == INVENTORY) msg = 59;
  336.     if (motion == 62 || motion == 65) msg = 42;
  337.     if (motion == 17) msg = 80;
  338.     rspeak(msg);
  339. }
  340.  
  341. /*
  342.     Routine to handle very special movement.
  343. */
  344. spcmove(rdest)
  345. int    rdest;
  346. {
  347.     switch(rdest-300) {
  348.     case 1:  /* plover movement via alcove */
  349.         if (!holding || (holding == 1 && toting(EMERALD)))
  350.             newloc = (99+100)-loc;
  351.         else
  352.             rspeak(117);
  353.         break;
  354.     case 2:  /* trying to remove plover, bad route */
  355.         drop(EMERALD, loc);
  356.         break;
  357.     case 3:  /* troll bridge */
  358.         if (prop[TROLL] == 1) {
  359.             pspeak(TROLL, 1);
  360.             prop[TROLL] = 0;
  361.             move(TROLL2, 0);
  362.             move((TROLL2+MAXOBJ), 0);
  363.             move(TROLL, 117);
  364.             move((TROLL+MAXOBJ), 122);
  365.             juggle(CHASM);
  366.             newloc = loc;
  367.         }
  368.         else {
  369.             newloc = (loc == 117 ? 122 : 117);
  370.             if (prop[TROLL] == 0)
  371.                 ++prop[TROLL];
  372.             if (!toting (BEAR))
  373.                 return;
  374.             rspeak(162);
  375.             prop[CHASM] = 1;
  376.             prop[TROLL] = 2;
  377.             drop(BEAR, newloc);
  378.             fixed[BEAR] = -1;
  379.             prop[BEAR] = 3;
  380.             if (prop[SPICES]<0)
  381.                 ++tally2;
  382.             oldloc2 = newloc;
  383.             death();
  384.         }
  385.         break;
  386.     default:
  387.         bug(38);
  388.     }
  389. }
  390.  
  391.  
  392. /*
  393.     Routine to handle player's demise via
  394.     waking up the dwarves...
  395. */
  396. dwarfend()
  397. {
  398.     death();
  399.     normend();
  400. }
  401.  
  402. /*
  403.     normal end of game
  404. */
  405. normend()
  406. {
  407.     score();
  408.     exit();
  409. }
  410.  
  411. /*
  412.     scoring
  413. */
  414. score()
  415. {
  416.     int    t, i, k, s;
  417.     s = t = 0;
  418.     for (i = 50; i<=MAXTRS; ++i) {
  419.         if (i == CHEST)
  420.             k = 14;
  421.         else if (i > CHEST)
  422.             k = 16;
  423.         else 
  424.             k = 12;
  425.         if (prop[i] >= 0)
  426.             t += 2;
  427.         if (place[i] == 3 && prop[i] == 0)
  428.             t += k-2;
  429.     }
  430.     printf("%-20s%d\n", "Treasures:", s = t);
  431.     t = (MAXDIE - numdie)*10;
  432.     if (t)
  433.         printf("%-20s%d\n", "Survival:", t);
  434.     s += t;
  435.     if (!gaveup)
  436.         s += 4;
  437.     t = dflag ? 25 : 0;
  438.     if (t)
  439.         printf("%-20s%d\n", "Getting well in:", t);
  440.     s += t;
  441.     t = closing ? 25 : 0;
  442.     if (t)
  443.         printf("%-20s%d\n", "Masters section:", t);
  444.     s += t;
  445.     if (closed) {
  446.         if (bonus == 0)
  447.             t = 10;
  448.         else if (bonus == 135)
  449.             t = 25;
  450.         else if (bonus == 134)
  451.             t = 30;
  452.         else if (bonus == 133)
  453.             t = 45;
  454.         printf("%-20s%d\n", "Bonus:", t);
  455.         s += t;
  456.     }
  457.     if (place[MAGAZINE] == 108)
  458.         s += 1;
  459.     s += 2;
  460.     printf("%-20s%d\n", "Score:", s);
  461. }
  462.  
  463. /*
  464.     Routine to handle the passing on of one
  465.     of the player's incarnations...
  466. */
  467. death()
  468. {
  469.     char    yea, i, j, k;
  470.  
  471.     if (!closing) {
  472.         yea = yes(81+numdie*2, 82+numdie*2, 54);
  473.         if (++numdie >= MAXDIE || !yea)
  474.             normend();
  475.         place[WATER] = 0;
  476.         place[OIL] = 0;
  477.         if (toting(LAMP))
  478.             prop[LAMP] = 0;
  479.         for (j = 1; j<101; ++j) {
  480.             i = 101-j;
  481.             if (toting (i))
  482.                 drop(i, i == LAMP ? 1:oldloc2);
  483.         }
  484.         newloc = 3;
  485.         oldloc = loc;
  486.         return;
  487.     }
  488.     /*
  489.        closing -- no resurrection...
  490.     */
  491.     rspeak(131);
  492.     ++numdie;
  493.     normend();
  494. }
  495.  
  496. /*
  497.     Routine to process an object.
  498. */
  499. doobj()
  500. {
  501.     char    i;
  502.     /*
  503.        is object here?  if so, transitive
  504.     */
  505.     if (fixed[object] == loc || here(object))
  506.         trobj();
  507.     /*
  508.         did he give grate as destination?
  509.     */
  510.     else if (object == GRATE) {
  511.         if (loc == 1 || loc == 4 || loc == 7) {
  512.             motion = DEPRESSION;
  513.             domove();
  514.         }
  515.         else if (loc>9 && loc<15) {
  516.             motion = ENTRANCE;
  517.             domove();
  518.         }
  519.     }
  520.     /*
  521.         is it a dwarf he is after?
  522.     */
  523.     else if (dcheck() && dflag >= 2) {
  524.         object = DWARF;
  525.         trobj();
  526.     }
  527.     /*
  528.        is he trying to get/use a liquid?
  529.     */
  530.     else if ((liq() == object && here(BOTTLE)) ||
  531.          liqloc(loc) == object)
  532.         trobj();
  533.     else if (object == PLANT && at(PLANT2) &&
  534.         prop[PLANT2] == 0) {
  535.         object = PLANT2;
  536.         trobj();
  537.     }
  538.     /*
  539.        is he trying to grab a knife?
  540.     */
  541.     else if (object == KNIFE && knfloc == loc) {
  542.         rspeak(116);
  543.         knfloc = -1;
  544.     }
  545.     /*
  546.        is he trying to get at dynamite?
  547.     */
  548.     else if (object == ROD && here(ROD2)) {
  549.         object = ROD2;
  550.         trobj();
  551.     }
  552.     else
  553.         printf("I see no %s here.\n", probj(object));
  554. }
  555.  
  556. /*
  557.     Routine to process an object being
  558.     referred to.
  559. */
  560. trobj()
  561. {
  562.     if (verb)
  563.         trverb();
  564.     else
  565.         printf("What do you want to do with the %s?\n",
  566.             probj(object));
  567. }
  568.  
  569. /*
  570.     Routine to print word corresponding to object
  571. */
  572. probj(object)
  573. {
  574.     int    wtype, wval;
  575.     analyze(word1, &wtype, &wval);
  576.     return (wtype == 1 ? word1 : word2);
  577. }
  578. /*
  579.     dwarf stuff.
  580. */
  581. dwarves()
  582. {
  583.     int    i, j, k, try, attack, stick, dtotal;
  584.     /*
  585.         see if dwarves allowed here
  586.     */
  587.     if (newloc == 0 || forced(newloc) || cond[newloc]&NOPIRAT)
  588.         return;
  589.     /*
  590.         see if dwarves are active.
  591.     */
  592.     if (!dflag) {
  593.         if (newloc > 15)
  594.             ++dflag;
  595.         return;
  596.     }
  597.     /*
  598.         if first close encounter (of 3rd kind)
  599.         kill 0, 1 or 2
  600.     */
  601.     if (dflag == 1) {
  602.         if (newloc < 15 || pct (95))
  603.             return;
  604.         ++dflag;
  605.         for (i = 1; i<3; ++i)
  606.             if (pct (50))
  607.                 dloc[rand()%5+1] = 0;
  608.         for (i = 1; i< (DWARFMAX-1); ++i) {
  609.             if (dloc[i] == newloc)
  610.                 dloc[i] = daltloc;
  611.             odloc[i] = dloc[i];
  612.         }
  613.         rspeak(3);
  614.         drop(AXE, newloc);
  615.         return;
  616.     }
  617.     dtotal = attack = stick = 0;
  618.     for (i = 1; i<DWARFMAX; ++i) {
  619.         if (dloc[i] == 0)
  620.             continue;
  621.         /*
  622.             move a dwarf at random.  we don't
  623.             have a matrix around to do it
  624.             as in the original version...
  625.         */
  626.         for (try = 1; try<20; ++try) {
  627.             j = rand()%106+15; /* allowed area */
  628.             if (j != odloc[i] && j != dloc[i] &&
  629.                 !(i == (DWARFMAX-1) && cond[j]&NOPIRAT == 1))
  630.                 break;
  631.         }
  632.         if (j == 0)
  633.             j = odloc[i];
  634.         odloc[i] = dloc[i];
  635.         dloc[i] = j;
  636.         if ((dseen[i] && newloc >= 15) ||
  637.             dloc[i] == newloc || odloc[i] == newloc)
  638.             dseen[i] = 1;
  639.         else
  640.             dseen[i] = 0;
  641.         if (!dseen[i])
  642.             continue;
  643.         dloc[i] = newloc;
  644.         if (i == 6)
  645.             dopirate();
  646.         else {
  647.             ++dtotal;
  648.             if (odloc[i] == dloc[i]) {
  649.                 ++attack;
  650.                 if (knfloc >= 0)
  651.                     knfloc = newloc;
  652.                 if (rand()%1000 < 95*(dflag-2))
  653.                     ++stick;
  654.             }
  655.         }
  656.     }
  657.     if (dtotal == 0)
  658.         return;
  659.     if (dtotal > 1)
  660.         printf("There are %d threatening little dwarves in the room with you!\n", dtotal);
  661.     else
  662.         rspeak(4);
  663.     if (attack == 0)
  664.         return;
  665.     if (dflag == 2)
  666.         ++dflag;
  667.     if (attack > 1) {
  668.         printf("%d of them throw knives at you!!\n", attack);
  669.         k = 6;
  670.     }
  671.     else {
  672.         rspeak(5);
  673.         k = 52;
  674.     }
  675.     if (stick <= 1) {
  676.         rspeak(stick+k);
  677.         if (stick == 0)
  678.             return;
  679.     }
  680.     else
  681.         printf("%d of them get you !!!\n", stick);
  682.     oldloc2 = newloc;
  683.     death();
  684. }
  685. /*
  686.     pirate stuff
  687. */
  688. dopirate()
  689. {
  690.     int    j, k;
  691.     if (newloc == chloc || prop[CHEST] >= 0)
  692.         return;
  693.     k = 0;
  694.     for (j = 50; j<=MAXTRS; ++j)
  695.         if (j != PYRAMID ||
  696.             (newloc != place[PYRAMID] &&
  697.              newloc != place[EMERALD])) {
  698.             if (toting(j))
  699.                 goto stealit;
  700.             if (here(j))
  701.                 ++k;
  702.         }
  703.     if (tally == tally2+1 && k == 0 && place[CHEST] == 0 &&
  704.         here(LAMP) && prop[LAMP] == 1) {
  705.         rspeak(186);
  706.         move(CHEST, chloc);
  707.         move(MESSAGE, chloc2);
  708.         dloc[6] = chloc;
  709.         odloc[6] = chloc;
  710.         dseen[6] = 0;
  711.         return;
  712.     }
  713.     if (odloc[6] != dloc[6] && pct(20)) {
  714.         rspeak(127);
  715.         return;
  716.     }
  717.     return;
  718.  
  719. stealit:
  720.  
  721.     rspeak(128);
  722.     if (place[MESSAGE] == 0)
  723.         move(CHEST, chloc);
  724.     move(MESSAGE, chloc2);
  725.     for (j = 50; j<=MAXTRS; ++j) {
  726.         if (j == PYRAMID &&
  727.             (newloc == place[PYRAMID] ||
  728.              newloc == place[EMERALD]))
  729.             continue;
  730.         if (at(j) && fixed[j] == 0)
  731.             carry(j, newloc);
  732.         if (toting(j))
  733.             drop(j, chloc);
  734.     }
  735.     dloc[6] = chloc;
  736.     odloc[6] = chloc;
  737.     dseen[6] = 0;
  738. }
  739. /*
  740.     special time limit stuff...
  741. */
  742. stimer()
  743. {
  744.     int    i;
  745.     foobar = foobar > 0 ?  -foobar : 0;
  746.     if (tally == 0 && loc >= 15 && loc != 33)
  747.         --clock;
  748.     if (clock == 0) {
  749.         /*
  750.             start closing the cave
  751.         */
  752.         prop[GRATE] = 0;
  753.         prop[FISSURE] = 0;
  754.         for (i = 1; i<DWARFMAX; ++i)
  755.             dseen[i] = 0;
  756.         move(TROLL, 0);
  757.         move((TROLL+MAXOBJ), 0);
  758.         move(TROLL2, 117);
  759.         move((TROLL2+MAXOBJ), 122);
  760.         juggle(CHASM);
  761.         if (prop[BEAR] != 3)
  762.             dstroy(BEAR);
  763.         prop[CHAIN] = 0;
  764.         fixed[CHAIN] = 0;
  765.         prop[AXE] = 0;
  766.         fixed[AXE] = 0;
  767.         rspeak(129);
  768.         clock = -1;
  769.         closing = 1;
  770.         return(0);
  771.     }
  772.     if (clock < 0)
  773.         --clock2;
  774.     if (clock2 == 0) {
  775.         /*
  776.             set up storage room...
  777.             and close the cave...
  778.         */
  779.         prop[BOTTLE] = put(BOTTLE, 115, 1);
  780.         prop[PLANT] = put(PLANT, 115, 0);
  781.         prop[OYSTER] = put(OYSTER, 115, 0);
  782.         prop[LAMP] = put(LAMP, 115, 0);
  783.         prop[ROD] = put(ROD, 115, 0);
  784.         prop[DWARF] = put(DWARF, 115, 0);
  785.         loc = 115;
  786.         oldloc = 115;
  787.         newloc = 115;
  788.         put(GRATE, 116, 0);
  789.         prop[SNAKE] = put(SNAKE, 116, 1);
  790.         prop[BIRD] = put(BIRD, 116, 1);
  791.         prop[CAGE] = put(CAGE, 116, 0);
  792.         prop[ROD2] = put(ROD2, 116, 0);
  793.         prop[PILLOW] = put(PILLOW, 116, 0);
  794.         prop[MIRROR] = put(MIRROR, 115, 0);
  795.         fixed[MIRROR] = 116;
  796.         for (i = 1; i<= MAXOBJ; ++i)
  797.             if (toting(i))
  798.                 dstroy(i);
  799.         rspeak(132);
  800.         closed = 1;
  801.         return(1);
  802.     }
  803.     if (prop[LAMP] == 1)
  804.         --limit;
  805.     if (limit <= 30 &&
  806.         here(BATTERIES) && prop[BATTERIES] == 0 &&
  807.         here(LAMP)) {
  808.         rspeak(188);
  809.         prop[BATTERIES] = 1;
  810.         if (toting(BATTERIES))
  811.             drop(BATTERIES, loc);
  812.         limit += 2500;
  813.         lmwarn = 0;
  814.         return(0);
  815.     }
  816.     if (limit == 0) {
  817.         --limit;
  818.         prop[LAMP] = 0;
  819.         if (here(LAMP))
  820.             rspeak(184);
  821.         return(0);
  822.     }
  823.     if (limit < 0 && loc <= 8) {
  824.         rspeak(185);
  825.         gaveup = 1;
  826.         normend();
  827.     }
  828.     if (limit <= 30) {
  829.         if (lmwarn || !here(LAMP))
  830.             return(0);
  831.         lmwarn = 1;
  832.         i = 187;
  833.         if (place[BATTERIES] == 0)
  834.             i = 183;
  835.         if (prop[BATTERIES] == 1)
  836.             i = 189;
  837.         rspeak(i);
  838.         return(0);
  839.     }
  840.     return(0);
  841. }
  842.  
  843. /*
  844.     random number seed
  845. */
  846. static    long    rnum = 0;
  847.  
  848. srand(n)
  849. short    n;
  850. {
  851.     rnum = (long)n;
  852. }
  853.  
  854. /*
  855.     random number
  856. */
  857. rand()
  858. {
  859.     rnum = rnum * 0x41C64E6D + 0x3039;
  860.     return((short)(rnum >> 16) & 0x7FFF);
  861. }
  862.  
  863.  
  864.